#!/usr/bin/env node

/**
 * 自定义启动脚本 - 数据库 + 服务器一体化启动
 * 支持开发环境和生产环境配置
 */

const { execSync, spawn } = require('child_process');
const { join } = require('path');
const { existsSync } = require('fs');

class CustomStarter {
    constructor(mode = 'dev') {
        this.mode = mode;
        this.projectRoot = join(__dirname, '..');
        this.scriptsDir = join(this.projectRoot, 'scripts');
        this.backendDir = join(this.projectRoot, 'backend');
        this.frontendDir = join(this.projectRoot, 'frontend');
        this.userClientDir = join(this.projectRoot, 'user-client');
        
        this.processes = [];
        this.databaseStarted = false;
        this.serverStarted = false;
        
        console.log(`🚀 自定义启动脚本启动 - 模式: ${mode.toUpperCase()}`);
        console.log('='.repeat(50));
    }

    // 打印启动信息
    printStartupInfo() {
        console.log('\n📋 启动配置信息:');
        console.log('   📁 项目根目录:', this.projectRoot);
        console.log('   🎯 启动模式:', this.mode);
        console.log('   🗄️ 数据库启动:', this.databaseStarted ? '✅ 已启动' : '❌ 未启动');
        console.log('   🖥️ 服务器启动:', this.serverStarted ? '✅ 已启动' : '❌ 未启动');
        console.log('');
    }

    // 检查环境
    async checkEnvironment() {
        console.log('🔍 检查运行环境...');
        
        try {
            // 检查Node.js版本
            const nodeVersion = execSync('node --version', { encoding: 'utf8' }).trim();
            console.log('   ✅ Node.js版本:', nodeVersion);
            
            // 检查npm版本
            const npmVersion = execSync('npm --version', { encoding: 'utf8' }).trim();
            console.log('   ✅ npm版本:', npmVersion);
            
            // 检查环境变量文件
            if (existsSync(join(this.projectRoot, '.env'))) {
                console.log('   ✅ 环境变量文件存在');
            } else {
                console.log('   ⚠️ 环境变量文件不存在，使用默认配置');
            }
            
            return true;
        } catch (error) {
            console.error('❌ 环境检查失败:', error.message);
            return false;
        }
    }

    // 启动数据库服务
    async startDatabases() {
        console.log('\n🗄️ 启动数据库服务...');
        
        try {
            // 检查数据库启动脚本
            const dbScript = join(this.scriptsDir, 'start-databases.sh');
            if (!existsSync(dbScript)) {
                console.log('   ⚠️ 数据库启动脚本不存在，跳过数据库启动');
                return false;
            }
            
            // 赋予执行权限
            execSync(`chmod +x "${dbScript}"`, { stdio: 'pipe' });
            
            // 启动数据库
            console.log('   🚀 执行数据库启动脚本...');
            execSync(`"${dbScript}"`, { stdio: 'inherit', cwd: this.projectRoot });
            
            this.databaseStarted = true;
            console.log('   ✅ 数据库服务启动完成');
            
            // 测试数据库连接
            console.log('   🔗 测试数据库连接...');
            try {
                execSync('npm run db:test', { stdio: 'pipe', cwd: this.projectRoot });
                console.log('   ✅ 数据库连接测试通过');
            } catch (error) {
                console.log('   ⚠️ 数据库连接测试失败，但服务将继续启动');
            }
            
            return true;
        } catch (error) {
            console.error('   ❌ 数据库启动失败:', error.message);
            console.log('   💡 应用将在无数据库模式下运行');
            return false;
        }
    }

    // 启动服务器服务
    async startServers() {
        console.log('\n🖥️ 启动服务器服务...');
        
        try {
            if (this.mode === 'dev') {
                // 开发模式：同时启动所有服务
                console.log('   🛠️ 开发模式 - 启动所有服务...');
                
                const devProcess = spawn('npm', ['run', 'dev'], {
                    stdio: 'inherit',
                    cwd: this.projectRoot,
                    shell: true
                });
                
                this.processes.push(devProcess);
                
            } else if (this.mode === 'prod') {
                // 生产模式：使用增强版启动
                console.log('   🚀 生产模式 - 启动增强版服务...');
                
                const startProcess = spawn('npm', ['run', 'start:enhanced'], {
                    stdio: 'inherit',
                    cwd: this.projectRoot,
                    shell: true
                });
                
                this.processes.push(startProcess);
                
            } else {
                // 默认模式：使用标准启动
                console.log('   ⚙️ 标准模式 - 启动标准服务...');
                
                const startProcess = spawn('npm', ['run', 'start:with-db'], {
                    stdio: 'inherit',
                    cwd: this.projectRoot,
                    shell: true
                });
                
                this.processes.push(startProcess);
            }
            
            this.serverStarted = true;
            console.log('   ✅ 服务器服务启动完成');
            return true;
            
        } catch (error) {
            console.error('   ❌ 服务器启动失败:', error.message);
            return false;
        }
    }

    // 显示服务状态
    showServiceStatus() {
        console.log('\n📊 服务状态报告:');
        console.log('-'.repeat(30));
        
        if (this.databaseStarted) {
            console.log('🗄️  数据库服务: ✅ 运行中');
        } else {
            console.log('🗄️  数据库服务: ❌ 未运行');
        }
        
        if (this.serverStarted) {
            console.log('🖥️  服务器服务: ✅ 运行中');
        } else {
            console.log('🖥️  服务器服务: ❌ 未运行');
        }
        
        console.log('-'.repeat(30));
    }

    // 显示访问信息
    showAccessInfo() {
        console.log('\n🌐 服务访问信息:');
        console.log('='.repeat(40));
        
        if (this.mode === 'dev') {
            console.log('🔧 开发环境:');
            console.log('   后端API: http://localhost:3000');
            console.log('   前端界面: http://localhost:8080');
            console.log('   用户端: http://localhost:3001');
            console.log('');
            console.log('📋 测试端点:');
            console.log('   健康检查: http://localhost:3000/health');
            console.log('   API测试: http://localhost:3000/test-api.html');
        } else {
            console.log('🚀 生产环境:');
            console.log('   主网站: http://localhost:80 (通过Nginx)');
            console.log('   后端API: http://localhost:3000');
            console.log('   前端界面: http://localhost:8080');
            console.log('');
            console.log('📊 监控端点:');
            console.log('   健康检查: http://localhost:3000/health');
            console.log('   性能监控: http://localhost:3000/metrics');
        }
        
        console.log('='.repeat(40));
    }

    // 优雅关闭
    setupGracefulShutdown() {
        const shutdown = (signal) => {
            console.log(`\n🛑 收到 ${signal} 信号，正在关闭服务...`);
            
            // 关闭所有子进程
            this.processes.forEach(process => {
                try {
                    process.kill();
                } catch (error) {
                    // 忽略进程已终止的错误
                }
            });
            
            console.log('✅ 所有服务已关闭');
            process.exit(0);
        };
        
        process.on('SIGINT', () => shutdown('SIGINT'));
        process.on('SIGTERM', () => shutdown('SIGTERM'));
    }

    // 主启动方法
    async start() {
        try {
            // 1. 显示启动信息
            this.printStartupInfo();
            
            // 2. 检查环境
            const envOk = await this.checkEnvironment();
            if (!envOk) {
                console.log('⚠️ 环境检查失败，但将继续启动流程');
            }
            
            // 3. 启动数据库服务
            await this.startDatabases();
            
            // 4. 启动服务器服务
            await this.startServers();
            
            // 5. 显示服务状态
            this.showServiceStatus();
            
            // 6. 显示访问信息
            this.showAccessInfo();
            
            // 7. 设置优雅关闭
            this.setupGracefulShutdown();
            
            console.log('\n🎉 自定义启动完成！');
            console.log('💡 按 Ctrl+C 停止所有服务');
            
        } catch (error) {
            console.error('❌ 启动过程中发生错误:', error);
            process.exit(1);
        }
    }
}

// 解析命令行参数
const args = process.argv.slice(2);
let mode = 'dev';

if (args.includes('--prod') || args.includes('-p')) {
    mode = 'prod';
} else if (args.includes('--dev') || args.includes('-d')) {
    mode = 'dev';
}

// 启动应用
const starter = new CustomStarter(mode);
starter.start().catch(error => {
    console.error('启动失败:', error);
    process.exit(1);
});